#include "JsonSerializable.h"

#include "./ElementRef.h"
#include "./UMLDiagramElementRef.h"

#include "../dc/Bounds.h"
#include "../dc/Color.h"
#include "../dc/Dimension.h"
#include "../dc/Point.h"
#include "../uml/Abstraction.h"
#include "../uml/AcceptCallAction.h"
#include "../uml/AcceptEventAction.h"
#include "../uml/Action.h"
#include "../uml/ActionExecutionSpecification.h"
#include "../uml/ActionInputPin.h"
#include "../uml/Activity.h"
#include "../uml/ActivityEdge.h"
#include "../uml/ActivityFinalNode.h"
#include "../uml/ActivityNode.h"
#include "../uml/ActivityParameterNode.h"
#include "../uml/ActivityPartition.h"
#include "../uml/Actor.h"
#include "../uml/AddStructuralFeatureValueAction.h"
#include "../uml/AddVariableValueAction.h"
#include "../uml/AnyReceiveEvent.h"
#include "../uml/Artifact.h"
#include "../uml/AssociationClass.h"
#include "../uml/Behavior.h"
#include "../uml/BehaviorExecutionSpecification.h"
#include "../uml/BehavioralFeature.h"
#include "../uml/BroadcastSignalAction.h"
#include "../uml/CallBehaviorAction.h"
#include "../uml/CallEvent.h"
#include "../uml/CallOperationAction.h"
#include "../uml/CentralBufferNode.h"
#include "../uml/ChangeEvent.h"
#include "../uml/Class.h"
#include "../uml/Classifier.h"
#include "../uml/ClassifierTemplateParameter.h"
#include "../uml/Clause.h"
#include "../uml/ClearAssociationAction.h"
#include "../uml/ClearStructuralFeatureAction.h"
#include "../uml/ClearVariableAction.h"
#include "../uml/Collaboration.h"
#include "../uml/CollaborationUse.h"
#include "../uml/CombinedFragment.h"
#include "../uml/Comment.h"
#include "../uml/CommunicationPath.h"
#include "../uml/Component.h"
#include "../uml/ComponentRealization.h"
#include "../uml/ConditionalNode.h"
#include "../uml/ConnectableElementTemplateParameter.h"
#include "../uml/ConnectionPointReference.h"
#include "../uml/Connector.h"
#include "../uml/ConsiderIgnoreFragment.h"
#include "../uml/Constraint.h"
#include "../uml/Continuation.h"
#include "../uml/ControlFlow.h"
#include "../uml/ControlNode.h"
#include "../uml/CreateLinkAction.h"
#include "../uml/CreateLinkObjectAction.h"
#include "../uml/CreateObjectAction.h"
#include "../uml/DataStoreNode.h"
#include "../uml/DataType.h"
#include "../uml/DecisionNode.h"
#include "../uml/Dependency.h"
#include "../uml/Deployment.h"
#include "../uml/DeploymentSpecification.h"
#include "../uml/DestroyLinkAction.h"
#include "../uml/DestroyObjectAction.h"
#include "../uml/DestructionOccurrenceSpecification.h"
#include "../uml/Device.h"
#include "../uml/Duration.h"
#include "../uml/DurationConstraint.h"
#include "../uml/DurationInterval.h"
#include "../uml/DurationObservation.h"
#include "../uml/Element.h"
#include "../uml/Enumeration.h"
#include "../uml/EnumerationLiteral.h"
#include "../uml/Event.h"
#include "../uml/ExceptionHandler.h"
#include "../uml/ExecutableNode.h"
#include "../uml/ExecutionEnvironment.h"
#include "../uml/ExecutionOccurrenceSpecification.h"
#include "../uml/ExecutionSpecification.h"
#include "../uml/ExpansionNode.h"
#include "../uml/ExpansionRegion.h"
#include "../uml/Expression.h"
#include "../uml/Extend.h"
#include "../uml/Extension.h"
#include "../uml/ExtensionEnd.h"
#include "../uml/ExtensionPoint.h"
#include "../uml/Feature.h"
#include "../uml/FinalNode.h"
#include "../uml/FinalState.h"
#include "../uml/FlowFinalNode.h"
#include "../uml/ForkNode.h"
#include "../uml/FunctionBehavior.h"
#include "../uml/Gate.h"
#include "../uml/GeneralOrdering.h"
#include "../uml/GeneralizationSet.h"
#include "../uml/Image.h"
#include "../uml/Include.h"
#include "../uml/InformationFlow.h"
#include "../uml/InformationItem.h"
#include "../uml/InitialNode.h"
#include "../uml/InputPin.h"
#include "../uml/InstanceSpecification.h"
#include "../uml/InstanceValue.h"
#include "../uml/Interaction.h"
#include "../uml/InteractionConstraint.h"
#include "../uml/InteractionOperand.h"
#include "../uml/InteractionUse.h"
#include "../uml/Interface.h"
#include "../uml/InterfaceRealization.h"
#include "../uml/InterruptibleActivityRegion.h"
#include "../uml/Interval.h"
#include "../uml/IntervalConstraint.h"
#include "../uml/InvocationAction.h"
#include "../uml/JoinNode.h"
#include "../uml/Lifeline.h"
#include "../uml/LinkAction.h"
#include "../uml/LinkEndCreationData.h"
#include "../uml/LinkEndData.h"
#include "../uml/LinkEndDestructionData.h"
#include "../uml/LiteralBoolean.h"
#include "../uml/LiteralInteger.h"
#include "../uml/LiteralNull.h"
#include "../uml/LiteralReal.h"
#include "../uml/LiteralSpecification.h"
#include "../uml/LiteralString.h"
#include "../uml/LiteralUnlimitedNatural.h"
#include "../uml/LoopNode.h"
#include "../uml/Manifestation.h"
#include "../uml/MergeNode.h"
#include "../uml/Message.h"
#include "../uml/MessageEvent.h"
#include "../uml/MessageOccurrenceSpecification.h"
#include "../uml/Model.h"
#include "../uml/NamedElement.h"
#include "../uml/Node.h"
#include "../uml/ObjectFlow.h"
#include "../uml/ObjectNode.h"
#include "../uml/Observation.h"
#include "../uml/OccurrenceSpecification.h"
#include "../uml/OpaqueAction.h"
#include "../uml/OpaqueBehavior.h"
#include "../uml/OpaqueExpression.h"
#include "../uml/Operation.h"
#include "../uml/OperationTemplateParameter.h"
#include "../uml/OutputPin.h"
#include "../uml/Package.h"
#include "../uml/PackageableElement.h"
#include "../uml/Parameter.h"
#include "../uml/ParameterSet.h"
#include "../uml/PartDecomposition.h"
#include "../uml/Pin.h"
#include "../uml/Port.h"
#include "../uml/PrimitiveType.h"
#include "../uml/Profile.h"
#include "../uml/Property.h"
#include "../uml/ProtocolStateMachine.h"
#include "../uml/ProtocolTransition.h"
#include "../uml/Pseudostate.h"
#include "../uml/QualifierValue.h"
#include "../uml/RaiseExceptionAction.h"
#include "../uml/ReadExtentAction.h"
#include "../uml/ReadIsClassifiedObjectAction.h"
#include "../uml/ReadLinkAction.h"
#include "../uml/ReadLinkObjectEndAction.h"
#include "../uml/ReadLinkObjectEndQualifierAction.h"
#include "../uml/ReadSelfAction.h"
#include "../uml/ReadStructuralFeatureAction.h"
#include "../uml/ReadVariableAction.h"
#include "../uml/Realization.h"
#include "../uml/Reception.h"
#include "../uml/ReclassifyObjectAction.h"
#include "../uml/RedefinableTemplateSignature.h"
#include "../uml/ReduceAction.h"
#include "../uml/Region.h"
#include "../uml/RemoveStructuralFeatureValueAction.h"
#include "../uml/RemoveVariableValueAction.h"
#include "../uml/ReplyAction.h"
#include "../uml/SendObjectAction.h"
#include "../uml/SendSignalAction.h"
#include "../uml/SequenceNode.h"
#include "../uml/Signal.h"
#include "../uml/SignalEvent.h"
#include "../uml/Slot.h"
#include "../uml/StartClassifierBehaviorAction.h"
#include "../uml/StartObjectBehaviorAction.h"
#include "../uml/State.h"
#include "../uml/StateInvariant.h"
#include "../uml/StateMachine.h"
#include "../uml/Stereotype.h"
#include "../uml/StringExpression.h"
#include "../uml/StructuralFeature.h"
#include "../uml/StructuralFeatureAction.h"
#include "../uml/StructuredActivityNode.h"
#include "../uml/Substitution.h"
#include "../uml/TemplateParameter.h"
#include "../uml/TemplateParameterSubstitution.h"
#include "../uml/TestIdentityAction.h"
#include "../uml/TimeConstraint.h"
#include "../uml/TimeEvent.h"
#include "../uml/TimeExpression.h"
#include "../uml/TimeInterval.h"
#include "../uml/TimeObservation.h"
#include "../uml/Transition.h"
#include "../uml/Trigger.h"
#include "../uml/Type.h"
#include "../uml/UnmarshallAction.h"
#include "../uml/Usage.h"
#include "../uml/UseCase.h"
#include "../uml/ValuePin.h"
#include "../uml/ValueSpecification.h"
#include "../uml/ValueSpecificationAction.h"
#include "../uml/VariableAction.h"
#include "../uml/WriteLinkAction.h"
#include "../uml/WriteStructuralFeatureAction.h"
#include "../uml/WriteVariableAction.h"
#include "../umldi/UMLActivityDiagram.h"
#include "../umldi/UMLAssociationEndLabel.h"
#include "../umldi/UMLAssociationOrConnectorOrLinkShape.h"
#include "../umldi/UMLClassDiagram.h"
#include "../umldi/UMLClassifierShape.h"
#include "../umldi/UMLCompartment.h"
#include "../umldi/UMLCompartmentableShape.h"
#include "../umldi/UMLComponentDiagram.h"
#include "../umldi/UMLCompositeStructureDiagram.h"
#include "../umldi/UMLDeploymentDiagram.h"
#include "../umldi/UMLDiagram.h"
#include "../umldi/UMLDiagramElement.h"
#include "../umldi/UMLDiagramWithAssociations.h"
#include "../umldi/UMLEdge.h"
#include "../umldi/UMLInteractionDiagram.h"
#include "../umldi/UMLInteractionTableLabel.h"
#include "../umldi/UMLKeywordLabel.h"
#include "../umldi/UMLLabel.h"
#include "../umldi/UMLMultiplicityLabel.h"
#include "../umldi/UMLNameLabel.h"
#include "../umldi/UMLObjectDiagram.h"
#include "../umldi/UMLPackageDiagram.h"
#include "../umldi/UMLProfileDiagram.h"
#include "../umldi/UMLRedefinesLabel.h"
#include "../umldi/UMLShape.h"
#include "../umldi/UMLStateMachineDiagram.h"
#include "../umldi/UMLStateShape.h"
#include "../umldi/UMLStereotypePropertyValueLabel.h"
#include "../umldi/UMLStructureDiagram.h"
#include "../umldi/UMLTypedElementLabel.h"
#include "../umldi/UMLUseCaseDiagram.h"

namespace uml {

void JsonSerializable::registerType(
    const QString key,
    std::function<shared_ptr<JsonSerializable>()> func
) {
    typeMap_.insert(key, func);
}

QMap<QString, std::function<shared_ptr<JsonSerializable>()>>
    JsonSerializable::typeMap_ = {
        {"uml::ElementRef",                           []() { return make_shared<ElementRef>(); }     },
        {"uml::UMLDiagramElementRef",
         []() { return make_shared<UMLDiagramElementRef>(); }                                        },
        {"uml::Bounds",                               []() { return make_shared<Bounds>(); }         },
        {"uml::Color",                                []() { return make_shared<Color>(); }          },
        {"uml::Dimension",                            []() { return make_shared<Dimension>(); }      },
        {"uml::Point",                                []() { return make_shared<Point>(); }          },
        {"uml::Abstraction",                          []() { return make_shared<Abstraction>(); }    },
        {"uml::AcceptCallAction",
         []() { return make_shared<AcceptCallAction>(); }                                            },
        {"uml::AcceptEventAction",
         []() { return make_shared<AcceptEventAction>(); }                                           },
        {"uml::Action",                               []() { return make_shared<Action>(); }         },
        {"uml::ActionExecutionSpecification",
         []() { return make_shared<ActionExecutionSpecification>(); }                                },
        {"uml::ActionInputPin",                       []() { return make_shared<ActionInputPin>(); } },
        {"uml::Activity",                             []() { return make_shared<Activity>(); }       },
        {"uml::ActivityEdge",                         []() { return make_shared<ActivityEdge>(); }   },
        {"uml::ActivityFinalNode",
         []() { return make_shared<ActivityFinalNode>(); }                                           },
        {"uml::ActivityNode",                         []() { return make_shared<ActivityNode>(); }   },
        {"uml::ActivityParameterNode",
         []() { return make_shared<ActivityParameterNode>(); }                                       },
        {"uml::ActivityPartition",
         []() { return make_shared<ActivityPartition>(); }                                           },
        {"uml::Actor",                                []() { return make_shared<Actor>(); }          },
        {"uml::AddStructuralFeatureValueAction",
         []() { return make_shared<AddStructuralFeatureValueAction>(); }                             },
        {"uml::AddVariableValueAction",
         []() { return make_shared<AddVariableValueAction>(); }                                      },
        {"uml::AnyReceiveEvent",                      []() { return make_shared<AnyReceiveEvent>(); }
        },
        {"uml::Artifact",                             []() { return make_shared<Artifact>(); }       },
        {"uml::AssociationClass",
         []() { return make_shared<AssociationClass>(); }                                            },
        {"uml::Behavior",                             []() { return make_shared<Behavior>(); }       },
        {"uml::BehaviorExecutionSpecification",
         []() { return make_shared<BehaviorExecutionSpecification>(); }                              },
        {"uml::BehavioralFeature",
         []() { return make_shared<BehavioralFeature>(); }                                           },
        {"uml::BroadcastSignalAction",
         []() { return make_shared<BroadcastSignalAction>(); }                                       },
        {"uml::CallBehaviorAction",
         []() { return make_shared<CallBehaviorAction>(); }                                          },
        {"uml::CallEvent",                            []() { return make_shared<CallEvent>(); }      },
        {"uml::CallOperationAction",
         []() { return make_shared<CallOperationAction>(); }                                         },
        {"uml::CentralBufferNode",
         []() { return make_shared<CentralBufferNode>(); }                                           },
        {"uml::ChangeEvent",                          []() { return make_shared<ChangeEvent>(); }    },
        {"uml::Class",                                []() { return make_shared<Class>(); }          },
        {"uml::Classifier",                           []() { return make_shared<Classifier>(); }     },
        {"uml::ClassifierTemplateParameter",
         []() { return make_shared<ClassifierTemplateParameter>(); }                                 },
        {"uml::Clause",                               []() { return make_shared<Clause>(); }         },
        {"uml::ClearAssociationAction",
         []() { return make_shared<ClearAssociationAction>(); }                                      },
        {"uml::ClearStructuralFeatureAction",
         []() { return make_shared<ClearStructuralFeatureAction>(); }                                },
        {"uml::ClearVariableAction",
         []() { return make_shared<ClearVariableAction>(); }                                         },
        {"uml::Collaboration",                        []() { return make_shared<Collaboration>(); }  },
        {"uml::CollaborationUse",
         []() { return make_shared<CollaborationUse>(); }                                            },
        {"uml::CombinedFragment",
         []() { return make_shared<CombinedFragment>(); }                                            },
        {"uml::Comment",                              []() { return make_shared<Comment>(); }        },
        {"uml::CommunicationPath",
         []() { return make_shared<CommunicationPath>(); }                                           },
        {"uml::Component",                            []() { return make_shared<Component>(); }      },
        {"uml::ComponentRealization",
         []() { return make_shared<ComponentRealization>(); }                                        },
        {"uml::ConditionalNode",                      []() { return make_shared<ConditionalNode>(); }
        },
        {"uml::ConnectableElementTemplateParameter",
         []() { return make_shared<ConnectableElementTemplateParameter>(); }                         },
        {"uml::ConnectionPointReference",
         []() { return make_shared<ConnectionPointReference>(); }                                    },
        {"uml::Connector",                            []() { return make_shared<Connector>(); }      },
        {"uml::ConsiderIgnoreFragment",
         []() { return make_shared<ConsiderIgnoreFragment>(); }                                      },
        {"uml::Constraint",                           []() { return make_shared<Constraint>(); }     },
        {"uml::Continuation",                         []() { return make_shared<Continuation>(); }   },
        {"uml::ControlFlow",                          []() { return make_shared<ControlFlow>(); }    },
        {"uml::ControlNode",                          []() { return make_shared<ControlNode>(); }    },
        {"uml::CreateLinkAction",
         []() { return make_shared<CreateLinkAction>(); }                                            },
        {"uml::CreateLinkObjectAction",
         []() { return make_shared<CreateLinkObjectAction>(); }                                      },
        {"uml::CreateObjectAction",
         []() { return make_shared<CreateObjectAction>(); }                                          },
        {"uml::DataStoreNode",                        []() { return make_shared<DataStoreNode>(); }  },
        {"uml::DataType",                             []() { return make_shared<DataType>(); }       },
        {"uml::DecisionNode",                         []() { return make_shared<DecisionNode>(); }   },
        {"uml::Dependency",                           []() { return make_shared<Dependency>(); }     },
        {"uml::Deployment",                           []() { return make_shared<Deployment>(); }     },
        {"uml::DeploymentSpecification",
         []() { return make_shared<DeploymentSpecification>(); }                                     },
        {"uml::DestroyLinkAction",
         []() { return make_shared<DestroyLinkAction>(); }                                           },
        {"uml::DestroyObjectAction",
         []() { return make_shared<DestroyObjectAction>(); }                                         },
        {"uml::DestructionOccurrenceSpecification",
         []() { return make_shared<DestructionOccurrenceSpecification>(); }                          },
        {"uml::Device",                               []() { return make_shared<Device>(); }         },
        {"uml::Duration",                             []() { return make_shared<Duration>(); }       },
        {"uml::DurationConstraint",
         []() { return make_shared<DurationConstraint>(); }                                          },
        {"uml::DurationInterval",
         []() { return make_shared<DurationInterval>(); }                                            },
        {"uml::DurationObservation",
         []() { return make_shared<DurationObservation>(); }                                         },
        {"uml::Element",                              []() { return make_shared<Element>(); }        },
        {"uml::Enumeration",                          []() { return make_shared<Enumeration>(); }    },
        {"uml::EnumerationLiteral",
         []() { return make_shared<EnumerationLiteral>(); }                                          },
        {"uml::Event",                                []() { return make_shared<Event>(); }          },
        {"uml::ExceptionHandler",
         []() { return make_shared<ExceptionHandler>(); }                                            },
        {"uml::ExecutableNode",                       []() { return make_shared<ExecutableNode>(); } },
        {"uml::ExecutionEnvironment",
         []() { return make_shared<ExecutionEnvironment>(); }                                        },
        {"uml::ExecutionOccurrenceSpecification",
         []() { return make_shared<ExecutionOccurrenceSpecification>(); }                            },
        {"uml::ExecutionSpecification",
         []() { return make_shared<ExecutionSpecification>(); }                                      },
        {"uml::ExpansionNode",                        []() { return make_shared<ExpansionNode>(); }  },
        {"uml::ExpansionRegion",                      []() { return make_shared<ExpansionRegion>(); }
        },
        {"uml::Expression",                           []() { return make_shared<Expression>(); }     },
        {"uml::Extend",                               []() { return make_shared<Extend>(); }         },
        {"uml::Extension",                            []() { return make_shared<Extension>(); }      },
        {"uml::ExtensionEnd",                         []() { return make_shared<ExtensionEnd>(); }   },
        {"uml::ExtensionPoint",                       []() { return make_shared<ExtensionPoint>(); } },
        {"uml::Feature",                              []() { return make_shared<Feature>(); }        },
        {"uml::FinalNode",                            []() { return make_shared<FinalNode>(); }      },
        {"uml::FinalState",                           []() { return make_shared<FinalState>(); }     },
        {"uml::FlowFinalNode",                        []() { return make_shared<FlowFinalNode>(); }  },
        {"uml::ForkNode",                             []() { return make_shared<ForkNode>(); }       },
        {"uml::FunctionBehavior",
         []() { return make_shared<FunctionBehavior>(); }                                            },
        {"uml::Gate",                                 []() { return make_shared<Gate>(); }           },
        {"uml::GeneralOrdering",                      []() { return make_shared<GeneralOrdering>(); }
        },
        {"uml::GeneralizationSet",
         []() { return make_shared<GeneralizationSet>(); }                                           },
        {"uml::Image",                                []() { return make_shared<Image>(); }          },
        {"uml::Include",                              []() { return make_shared<Include>(); }        },
        {"uml::InformationFlow",                      []() { return make_shared<InformationFlow>(); }
        },
        {"uml::InformationItem",                      []() { return make_shared<InformationItem>(); }
        },
        {"uml::InitialNode",                          []() { return make_shared<InitialNode>(); }    },
        {"uml::InputPin",                             []() { return make_shared<InputPin>(); }       },
        {"uml::InstanceSpecification",
         []() { return make_shared<InstanceSpecification>(); }                                       },
        {"uml::InstanceValue",                        []() { return make_shared<InstanceValue>(); }  },
        {"uml::Interaction",                          []() { return make_shared<Interaction>(); }    },
        {"uml::InteractionConstraint",
         []() { return make_shared<InteractionConstraint>(); }                                       },
        {"uml::InteractionOperand",
         []() { return make_shared<InteractionOperand>(); }                                          },
        {"uml::InteractionUse",                       []() { return make_shared<InteractionUse>(); } },
        {"uml::Interface",                            []() { return make_shared<Interface>(); }      },
        {"uml::InterfaceRealization",
         []() { return make_shared<InterfaceRealization>(); }                                        },
        {"uml::InterruptibleActivityRegion",
         []() { return make_shared<InterruptibleActivityRegion>(); }                                 },
        {"uml::Interval",                             []() { return make_shared<Interval>(); }       },
        {"uml::IntervalConstraint",
         []() { return make_shared<IntervalConstraint>(); }                                          },
        {"uml::InvocationAction",
         []() { return make_shared<InvocationAction>(); }                                            },
        {"uml::JoinNode",                             []() { return make_shared<JoinNode>(); }       },
        {"uml::Lifeline",                             []() { return make_shared<Lifeline>(); }       },
        {"uml::LinkAction",                           []() { return make_shared<LinkAction>(); }     },
        {"uml::LinkEndCreationData",
         []() { return make_shared<LinkEndCreationData>(); }                                         },
        {"uml::LinkEndData",                          []() { return make_shared<LinkEndData>(); }    },
        {"uml::LinkEndDestructionData",
         []() { return make_shared<LinkEndDestructionData>(); }                                      },
        {"uml::LiteralBoolean",                       []() { return make_shared<LiteralBoolean>(); } },
        {"uml::LiteralInteger",                       []() { return make_shared<LiteralInteger>(); } },
        {"uml::LiteralNull",                          []() { return make_shared<LiteralNull>(); }    },
        {"uml::LiteralReal",                          []() { return make_shared<LiteralReal>(); }    },
        {"uml::LiteralSpecification",
         []() { return make_shared<LiteralSpecification>(); }                                        },
        {"uml::LiteralString",                        []() { return make_shared<LiteralString>(); }  },
        {"uml::LiteralUnlimitedNatural",
         []() { return make_shared<LiteralUnlimitedNatural>(); }                                     },
        {"uml::LoopNode",                             []() { return make_shared<LoopNode>(); }       },
        {"uml::Manifestation",                        []() { return make_shared<Manifestation>(); }  },
        {"uml::MergeNode",                            []() { return make_shared<MergeNode>(); }      },
        {"uml::Message",                              []() { return make_shared<Message>(); }        },
        {"uml::MessageEvent",                         []() { return make_shared<MessageEvent>(); }   },
        {"uml::MessageOccurrenceSpecification",
         []() { return make_shared<MessageOccurrenceSpecification>(); }                              },
        {"uml::Model",                                []() { return make_shared<Model>(); }          },
        {"uml::NamedElement",                         []() { return make_shared<NamedElement>(); }   },
        {"uml::Node",                                 []() { return make_shared<Node>(); }           },
        {"uml::ObjectFlow",                           []() { return make_shared<ObjectFlow>(); }     },
        {"uml::ObjectNode",                           []() { return make_shared<ObjectNode>(); }     },
        {"uml::Observation",                          []() { return make_shared<Observation>(); }    },
        {"uml::OccurrenceSpecification",
         []() { return make_shared<OccurrenceSpecification>(); }                                     },
        {"uml::OpaqueAction",                         []() { return make_shared<OpaqueAction>(); }   },
        {"uml::OpaqueBehavior",                       []() { return make_shared<OpaqueBehavior>(); } },
        {"uml::OpaqueExpression",
         []() { return make_shared<OpaqueExpression>(); }                                            },
        {"uml::Operation",                            []() { return make_shared<Operation>(); }      },
        {"uml::OperationTemplateParameter",
         []() { return make_shared<OperationTemplateParameter>(); }                                  },
        {"uml::OutputPin",                            []() { return make_shared<OutputPin>(); }      },
        {"uml::Package",                              []() { return make_shared<Package>(); }        },
        {"uml::PackageableElement",
         []() { return make_shared<PackageableElement>(); }                                          },
        {"uml::Parameter",                            []() { return make_shared<Parameter>(); }      },
        {"uml::ParameterSet",                         []() { return make_shared<ParameterSet>(); }   },
        {"uml::PartDecomposition",
         []() { return make_shared<PartDecomposition>(); }                                           },
        {"uml::Pin",                                  []() { return make_shared<Pin>(); }            },
        {"uml::Port",                                 []() { return make_shared<Port>(); }           },
        {"uml::PrimitiveType",                        []() { return make_shared<PrimitiveType>(); }  },
        {"uml::Profile",                              []() { return make_shared<Profile>(); }        },
        {"uml::Property",                             []() { return make_shared<Property>(); }       },
        {"uml::ProtocolStateMachine",
         []() { return make_shared<ProtocolStateMachine>(); }                                        },
        {"uml::ProtocolTransition",
         []() { return make_shared<ProtocolTransition>(); }                                          },
        {"uml::Pseudostate",                          []() { return make_shared<Pseudostate>(); }    },
        {"uml::QualifierValue",                       []() { return make_shared<QualifierValue>(); } },
        {"uml::RaiseExceptionAction",
         []() { return make_shared<RaiseExceptionAction>(); }                                        },
        {"uml::ReadExtentAction",
         []() { return make_shared<ReadExtentAction>(); }                                            },
        {"uml::ReadIsClassifiedObjectAction",
         []() { return make_shared<ReadIsClassifiedObjectAction>(); }                                },
        {"uml::ReadLinkAction",                       []() { return make_shared<ReadLinkAction>(); } },
        {"uml::ReadLinkObjectEndAction",
         []() { return make_shared<ReadLinkObjectEndAction>(); }                                     },
        {"uml::ReadLinkObjectEndQualifierAction",
         []() { return make_shared<ReadLinkObjectEndQualifierAction>(); }                            },
        {"uml::ReadSelfAction",                       []() { return make_shared<ReadSelfAction>(); } },
        {"uml::ReadStructuralFeatureAction",
         []() { return make_shared<ReadStructuralFeatureAction>(); }                                 },
        {"uml::ReadVariableAction",
         []() { return make_shared<ReadVariableAction>(); }                                          },
        {"uml::Realization",                          []() { return make_shared<Realization>(); }    },
        {"uml::Reception",                            []() { return make_shared<Reception>(); }      },
        {"uml::ReclassifyObjectAction",
         []() { return make_shared<ReclassifyObjectAction>(); }                                      },
        {"uml::RedefinableTemplateSignature",
         []() { return make_shared<RedefinableTemplateSignature>(); }                                },
        {"uml::ReduceAction",                         []() { return make_shared<ReduceAction>(); }   },
        {"uml::Region",                               []() { return make_shared<Region>(); }         },
        {"uml::RemoveStructuralFeatureValueAction",
         []() { return make_shared<RemoveStructuralFeatureValueAction>(); }                          },
        {"uml::RemoveVariableValueAction",
         []() { return make_shared<RemoveVariableValueAction>(); }                                   },
        {"uml::ReplyAction",                          []() { return make_shared<ReplyAction>(); }    },
        {"uml::SendObjectAction",
         []() { return make_shared<SendObjectAction>(); }                                            },
        {"uml::SendSignalAction",
         []() { return make_shared<SendSignalAction>(); }                                            },
        {"uml::SequenceNode",                         []() { return make_shared<SequenceNode>(); }   },
        {"uml::Signal",                               []() { return make_shared<Signal>(); }         },
        {"uml::SignalEvent",                          []() { return make_shared<SignalEvent>(); }    },
        {"uml::Slot",                                 []() { return make_shared<Slot>(); }           },
        {"uml::StartClassifierBehaviorAction",
         []() { return make_shared<StartClassifierBehaviorAction>(); }                               },
        {"uml::StartObjectBehaviorAction",
         []() { return make_shared<StartObjectBehaviorAction>(); }                                   },
        {"uml::State",                                []() { return make_shared<State>(); }          },
        {"uml::StateInvariant",                       []() { return make_shared<StateInvariant>(); } },
        {"uml::StateMachine",                         []() { return make_shared<StateMachine>(); }   },
        {"uml::Stereotype",                           []() { return make_shared<Stereotype>(); }     },
        {"uml::StringExpression",
         []() { return make_shared<StringExpression>(); }                                            },
        {"uml::StructuralFeature",
         []() { return make_shared<StructuralFeature>(); }                                           },
        {"uml::StructuralFeatureAction",
         []() { return make_shared<StructuralFeatureAction>(); }                                     },
        {"uml::StructuredActivityNode",
         []() { return make_shared<StructuredActivityNode>(); }                                      },
        {"uml::Substitution",                         []() { return make_shared<Substitution>(); }   },
        {"uml::TemplateParameter",
         []() { return make_shared<TemplateParameter>(); }                                           },
        {"uml::TemplateParameterSubstitution",
         []() { return make_shared<TemplateParameterSubstitution>(); }                               },
        {"uml::TestIdentityAction",
         []() { return make_shared<TestIdentityAction>(); }                                          },
        {"uml::TimeConstraint",                       []() { return make_shared<TimeConstraint>(); } },
        {"uml::TimeEvent",                            []() { return make_shared<TimeEvent>(); }      },
        {"uml::TimeExpression",                       []() { return make_shared<TimeExpression>(); } },
        {"uml::TimeInterval",                         []() { return make_shared<TimeInterval>(); }   },
        {"uml::TimeObservation",                      []() { return make_shared<TimeObservation>(); }
        },
        {"uml::Transition",                           []() { return make_shared<Transition>(); }     },
        {"uml::Trigger",                              []() { return make_shared<Trigger>(); }        },
        {"uml::Type",                                 []() { return make_shared<Type>(); }           },
        {"uml::UnmarshallAction",
         []() { return make_shared<UnmarshallAction>(); }                                            },
        {"uml::Usage",                                []() { return make_shared<Usage>(); }          },
        {"uml::UseCase",                              []() { return make_shared<UseCase>(); }        },
        {"uml::ValuePin",                             []() { return make_shared<ValuePin>(); }       },
        {"uml::ValueSpecification",
         []() { return make_shared<ValueSpecification>(); }                                          },
        {"uml::ValueSpecificationAction",
         []() { return make_shared<ValueSpecificationAction>(); }                                    },
        {"uml::VariableAction",                       []() { return make_shared<VariableAction>(); } },
        {"uml::WriteLinkAction",                      []() { return make_shared<WriteLinkAction>(); }
        },
        {"uml::WriteStructuralFeatureAction",
         []() { return make_shared<WriteStructuralFeatureAction>(); }                                },
        {"uml::WriteVariableAction",
         []() { return make_shared<WriteVariableAction>(); }                                         },
        {"uml::UMLActivityDiagram",
         []() { return make_shared<UMLActivityDiagram>(); }                                          },
        {"uml::UMLAssociationEndLabel",
         []() { return make_shared<UMLAssociationEndLabel>(); }                                      },
        {"uml::UMLAssociationOrConnectorOrLinkShape",
         []() { return make_shared<UMLAssociationOrConnectorOrLinkShape>(); }                        },
        {"uml::UMLClassDiagram",                      []() { return make_shared<UMLClassDiagram>(); }
        },
        {"uml::UMLClassifierShape",
         []() { return make_shared<UMLClassifierShape>(); }                                          },
        {"uml::UMLCompartment",                       []() { return make_shared<UMLCompartment>(); } },
        {"uml::UMLCompartmentableShape",
         []() { return make_shared<UMLCompartmentableShape>(); }                                     },
        {"uml::UMLComponentDiagram",
         []() { return make_shared<UMLComponentDiagram>(); }                                         },
        {"uml::UMLCompositeStructureDiagram",
         []() { return make_shared<UMLCompositeStructureDiagram>(); }                                },
        {"uml::UMLDeploymentDiagram",
         []() { return make_shared<UMLDeploymentDiagram>(); }                                        },
        {"uml::UMLDiagram",                           []() { return make_shared<UMLDiagram>(); }     },
        {"uml::UMLDiagramElement",
         []() { return make_shared<UMLDiagramElement>(); }                                           },
        {"uml::UMLDiagramWithAssociations",
         []() { return make_shared<UMLDiagramWithAssociations>(); }                                  },
        {"uml::UMLEdge",                              []() { return make_shared<UMLEdge>(); }        },
        {"uml::UMLInteractionDiagram",
         []() { return make_shared<UMLInteractionDiagram>(); }                                       },
        {"uml::UMLInteractionTableLabel",
         []() { return make_shared<UMLInteractionTableLabel>(); }                                    },
        {"uml::UMLKeywordLabel",                      []() { return make_shared<UMLKeywordLabel>(); }
        },
        {"uml::UMLLabel",                             []() { return make_shared<UMLLabel>(); }       },
        {"uml::UMLMultiplicityLabel",
         []() { return make_shared<UMLMultiplicityLabel>(); }                                        },
        {"uml::UMLNameLabel",                         []() { return make_shared<UMLNameLabel>(); }   },
        {"uml::UMLObjectDiagram",
         []() { return make_shared<UMLObjectDiagram>(); }                                            },
        {"uml::UMLPackageDiagram",
         []() { return make_shared<UMLPackageDiagram>(); }                                           },
        {"uml::UMLProfileDiagram",
         []() { return make_shared<UMLProfileDiagram>(); }                                           },
        {"uml::UMLRedefinesLabel",
         []() { return make_shared<UMLRedefinesLabel>(); }                                           },
        {"uml::UMLShape",                             []() { return make_shared<UMLShape>(); }       },
        {"uml::UMLStateMachineDiagram",
         []() { return make_shared<UMLStateMachineDiagram>(); }                                      },
        {"uml::UMLStateShape",                        []() { return make_shared<UMLStateShape>(); }  },
        {"uml::UMLStereotypePropertyValueLabel",
         []() { return make_shared<UMLStereotypePropertyValueLabel>(); }                             },
        {"uml::UMLStructureDiagram",
         []() { return make_shared<UMLStructureDiagram>(); }                                         },
        {"uml::UMLTypedElementLabel",
         []() { return make_shared<UMLTypedElementLabel>(); }                                        },
        {"uml::UMLUseCaseDiagram",
         []() { return make_shared<UMLUseCaseDiagram>(); }                                           },
};

} // namespace uml
